home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gas_251.zip / bin_251 / bfd / reloc.c < prev    next >
C/C++ Source or Header  |  1994-10-10  |  67KB  |  2,266 lines
  1. /* BFD support for handling relocation entries.
  2.    Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  3.    Written by Cygnus Support.
  4.  
  5. This file is part of BFD, the Binary File Descriptor library.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /*
  22. SECTION
  23.     Relocations
  24.  
  25.     BFD maintains relocations in much the same way it maintains
  26.     symbols: they are left alone until required, then read in
  27.     en-mass and translated into an internal form.  A common
  28.     routine <<bfd_perform_relocation>> acts upon the
  29.     canonical form to do the fixup.
  30.  
  31.     Relocations are maintained on a per section basis,
  32.     while symbols are maintained on a per BFD basis.
  33.  
  34.     All that a back end has to do to fit the BFD interface is to create
  35.     a <<struct reloc_cache_entry>> for each relocation
  36.     in a particular section, and fill in the right bits of the structures.
  37.  
  38. @menu
  39. @* typedef arelent::
  40. @* howto manager::
  41. @end menu
  42.  
  43. */
  44.  
  45. /* DO compile in the reloc_code name table from libbfd.h.  */
  46. #define _BFD_MAKE_TABLE_bfd_reloc_code_real
  47.  
  48. #include "bfd.h"
  49. #include "sysdep.h"
  50. #include "bfdlink.h"
  51. #include "libbfd.h"
  52. /*
  53. DOCDD
  54. INODE
  55.     typedef arelent, howto manager, Relocations, Relocations
  56.  
  57. SUBSECTION
  58.     typedef arelent
  59.  
  60.     This is the structure of a relocation entry:
  61.  
  62. CODE_FRAGMENT
  63. .
  64. .typedef enum bfd_reloc_status
  65. .{
  66. .       {* No errors detected *}
  67. .  bfd_reloc_ok,
  68. .
  69. .       {* The relocation was performed, but there was an overflow. *}
  70. .  bfd_reloc_overflow,
  71. .
  72. .       {* The address to relocate was not within the section supplied. *}
  73. .  bfd_reloc_outofrange,
  74. .
  75. .       {* Used by special functions *}
  76. .  bfd_reloc_continue,
  77. .
  78. .       {* Unsupported relocation size requested. *}
  79. .  bfd_reloc_notsupported,
  80. .
  81. .       {* Unused *}
  82. .  bfd_reloc_other,
  83. .
  84. .       {* The symbol to relocate against was undefined. *}
  85. .  bfd_reloc_undefined,
  86. .
  87. .       {* The relocation was performed, but may not be ok - presently
  88. .          generated only when linking i960 coff files with i960 b.out
  89. .          symbols.  If this type is returned, the error_message argument
  90. .          to bfd_perform_relocation will be set.  *}
  91. .  bfd_reloc_dangerous
  92. . }
  93. . bfd_reloc_status_type;
  94. .
  95. .
  96. .typedef struct reloc_cache_entry
  97. .{
  98. .       {* A pointer into the canonical table of pointers  *}
  99. .  struct symbol_cache_entry **sym_ptr_ptr;
  100. .
  101. .       {* offset in section *}
  102. .  bfd_size_type address;
  103. .
  104. .       {* addend for relocation value *}
  105. .  bfd_vma addend;
  106. .
  107. .       {* Pointer to how to perform the required relocation *}
  108. .  const struct reloc_howto_struct *howto;
  109. .
  110. .} arelent;
  111.  
  112. */
  113.  
  114. /*
  115. DESCRIPTION
  116.  
  117.         Here is a description of each of the fields within an <<arelent>>:
  118.  
  119.         o <<sym_ptr_ptr>>
  120.  
  121.         The symbol table pointer points to a pointer to the symbol
  122.         associated with the relocation request.  It is
  123.         the pointer into the table returned by the back end's
  124.         <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
  125.         through a pointer to a pointer so that tools like the linker
  126.         can fix up all the symbols of the same name by modifying only
  127.         one pointer. The relocation routine looks in the symbol and
  128.         uses the base of the section the symbol is attached to and the
  129.         value of the symbol as the initial relocation offset. If the
  130.         symbol pointer is zero, then the section provided is looked up.
  131.  
  132.         o <<address>>
  133.  
  134.         The <<address>> field gives the offset in bytes from the base of
  135.         the section data which owns the relocation record to the first
  136.         byte of relocatable information. The actual data relocated
  137.         will be relative to this point; for example, a relocation
  138.         type which modifies the bottom two bytes of a four byte word
  139.         would not touch the first byte pointed to in a big endian
  140.         world.
  141.     
  142.     o <<addend>>
  143.  
  144.     The <<addend>> is a value provided by the back end to be added (!)
  145.     to the relocation offset. Its interpretation is dependent upon
  146.     the howto. For example, on the 68k the code:
  147.  
  148.  
  149. |        char foo[];
  150. |        main()
  151. |                {
  152. |                return foo[0x12345678];
  153. |                }
  154.  
  155.         Could be compiled into:
  156.  
  157. |        linkw fp,#-4
  158. |        moveb @@#12345678,d0
  159. |        extbl d0
  160. |        unlk fp
  161. |        rts
  162.  
  163.  
  164.         This could create a reloc pointing to <<foo>>, but leave the
  165.         offset in the data, something like:
  166.  
  167.  
  168. |RELOCATION RECORDS FOR [.text]:
  169. |offset   type      value
  170. |00000006 32        _foo
  171. |
  172. |00000000 4e56 fffc          ; linkw fp,#-4
  173. |00000004 1039 1234 5678     ; moveb @@#12345678,d0
  174. |0000000a 49c0               ; extbl d0
  175. |0000000c 4e5e               ; unlk fp
  176. |0000000e 4e75               ; rts
  177.  
  178.  
  179.         Using coff and an 88k, some instructions don't have enough
  180.         space in them to represent the full address range, and
  181.         pointers have to be loaded in two parts. So you'd get something like:
  182.  
  183.  
  184. |        or.u     r13,r0,hi16(_foo+0x12345678)
  185. |        ld.b     r2,r13,lo16(_foo+0x12345678)
  186. |        jmp      r1
  187.  
  188.  
  189.         This should create two relocs, both pointing to <<_foo>>, and with
  190.         0x12340000 in their addend field. The data would consist of:
  191.  
  192.  
  193. |RELOCATION RECORDS FOR [.text]:
  194. |offset   type      value
  195. |00000002 HVRT16    _foo+0x12340000
  196. |00000006 LVRT16    _foo+0x12340000
  197. |
  198. |00000000 5da05678           ; or.u r13,r0,0x5678
  199. |00000004 1c4d5678           ; ld.b r2,r13,0x5678
  200. |00000008 f400c001           ; jmp r1
  201.  
  202.  
  203.         The relocation routine digs out the value from the data, adds
  204.         it to the addend to get the original offset, and then adds the
  205.         value of <<_foo>>. Note that all 32 bits have to be kept around
  206.         somewhere, to cope with carry from bit 15 to bit 16.
  207.  
  208.         One further example is the sparc and the a.out format. The
  209.         sparc has a similar problem to the 88k, in that some
  210.         instructions don't have room for an entire offset, but on the
  211.         sparc the parts are created in odd sized lumps. The designers of
  212.         the a.out format chose to not use the data within the section
  213.         for storing part of the offset; all the offset is kept within
  214.         the reloc. Anything in the data should be ignored.
  215.  
  216. |        save %sp,-112,%sp
  217. |        sethi %hi(_foo+0x12345678),%g2
  218. |        ldsb [%g2+%lo(_foo+0x12345678)],%i0
  219. |        ret
  220. |        restore
  221.  
  222.         Both relocs contain a pointer to <<foo>>, and the offsets
  223.         contain junk.
  224.  
  225.  
  226. |RELOCATION RECORDS FOR [.text]:
  227. |offset   type      value
  228. |00000004 HI22      _foo+0x12345678
  229. |00000008 LO10      _foo+0x12345678
  230. |
  231. |00000000 9de3bf90     ; save %sp,-112,%sp
  232. |00000004 05000000     ; sethi %hi(_foo+0),%g2
  233. |00000008 f048a000     ; ldsb [%g2+%lo(_foo+0)],%i0
  234. |0000000c 81c7e008     ; ret
  235. |00000010 81e80000     ; restore
  236.  
  237.  
  238.         o <<howto>>
  239.  
  240.         The <<howto>> field can be imagined as a
  241.         relocation instruction. It is a pointer to a structure which
  242.         contains information on what to do with all of the other
  243.         information in the reloc record and data section. A back end
  244.         would normally have a relocation instruction set and turn
  245.         relocations into pointers to the correct structure on input -
  246.         but it would be possible to create each howto field on demand.
  247.  
  248. */
  249.  
  250. /*
  251. SUBSUBSECTION
  252.     <<enum complain_overflow>>
  253.  
  254.     Indicates what sort of overflow checking should be done when
  255.     performing a relocation.
  256.  
  257. CODE_FRAGMENT
  258. .
  259. .enum complain_overflow
  260. .{
  261. .    {* Do not complain on overflow. *}
  262. .  complain_overflow_dont,
  263. .
  264. .    {* Complain if the bitfield overflows, whether it is considered
  265. .       as signed or unsigned. *}
  266. .  complain_overflow_bitfield,
  267. .
  268. .    {* Complain if the value overflows when considered as signed
  269. .       number. *}
  270. .  complain_overflow_signed,
  271. .
  272. .    {* Complain if the value overflows when considered as an
  273. .       unsigned number. *}
  274. .  complain_overflow_unsigned
  275. .};
  276.  
  277. */
  278.  
  279. /*
  280. SUBSUBSECTION
  281.         <<reloc_howto_type>>
  282.  
  283.         The <<reloc_howto_type>> is a structure which contains all the
  284.         information that libbfd needs to know to tie up a back end's data.
  285.  
  286. CODE_FRAGMENT
  287. .struct symbol_cache_entry;        {* Forward declaration *}
  288. .
  289. .typedef unsigned char bfd_byte;
  290. .typedef struct reloc_howto_struct reloc_howto_type;
  291. .
  292. .struct reloc_howto_struct
  293. .{
  294. .       {*  The type field has mainly a documetary use - the back end can
  295. .           do what it wants with it, though normally the back end's
  296. .           external idea of what a reloc number is stored
  297. .           in this field. For example, a PC relative word relocation
  298. .           in a coff environment has the type 023 - because that's
  299. .           what the outside world calls a R_PCRWORD reloc. *}
  300. .  unsigned int type;
  301. .
  302. .       {*  The value the final relocation is shifted right by. This drops
  303. .           unwanted data from the relocation.  *}
  304. .  unsigned int rightshift;
  305. .
  306. .    {*  The size of the item to be relocated.  This is *not* a
  307. .        power-of-two measure.  To get the number of bytes operated
  308. .        on by a type of relocation, use bfd_get_reloc_size.  *}
  309. .  int size;
  310. .
  311. .       {*  The number of bits in the item to be relocated.  This is used
  312. .        when doing overflow checking.  *}
  313. .  unsigned int bitsize;
  314. .
  315. .       {*  Notes that the relocation is relative to the location in the
  316. .           data section of the addend. The relocation function will
  317. .           subtract from the relocation value the address of the location
  318. .           being relocated. *}
  319. .  boolean pc_relative;
  320. .
  321. .    {*  The bit position of the reloc value in the destination.
  322. .        The relocated value is left shifted by this amount. *}
  323. .  unsigned int bitpos;
  324. .
  325. .    {* What type of overflow error should be checked for when
  326. .       relocating. *}
  327. .  enum complain_overflow complain_on_overflow;
  328. .
  329. .       {* If this field is non null, then the supplied function is
  330. .          called rather than the normal function. This allows really
  331. .          strange relocation methods to be accomodated (e.g., i960 callj
  332. .          instructions). *}
  333. .  bfd_reloc_status_type (*special_function)
  334. .                    PARAMS ((bfd *abfd,
  335. .                         arelent *reloc_entry,
  336. .                                            struct symbol_cache_entry *symbol,
  337. .                                            PTR data,
  338. .                                            asection *input_section,
  339. .                                            bfd *output_bfd,
  340. .                                            char **error_message));
  341. .
  342. .       {* The textual name of the relocation type. *}
  343. .  char *name;
  344. .
  345. .       {* When performing a partial link, some formats must modify the
  346. .          relocations rather than the data - this flag signals this.*}
  347. .  boolean partial_inplace;
  348. .
  349. .       {* The src_mask selects which parts of the read in data
  350. .          are to be used in the relocation sum.  E.g., if this was an 8 bit
  351. .          bit of data which we read and relocated, this would be
  352. .          0x000000ff. When we have relocs which have an addend, such as
  353. .          sun4 extended relocs, the value in the offset part of a
  354. .          relocating field is garbage so we never use it. In this case
  355. .          the mask would be 0x00000000. *}
  356. .  bfd_vma src_mask;
  357. .
  358. .       {* The dst_mask selects which parts of the instruction are replaced
  359. .          into the instruction. In most cases src_mask == dst_mask,
  360. .          except in the above special case, where dst_mask would be
  361. .          0x000000ff, and src_mask would be 0x00000000.   *}
  362. .  bfd_vma dst_mask;
  363. .
  364. .       {* When some formats create PC relative instructions, they leave
  365. .          the value of the pc of the place being relocated in the offset
  366. .          slot of the instruction, so that a PC relative relocation can
  367. .          be made just by adding in an ordinary offset (e.g., sun3 a.out).
  368. .          Some formats leave the displacement part of an instruction
  369. .          empty (e.g., m88k bcs); this flag signals the fact.*}
  370. .  boolean pcrel_offset;
  371. .
  372. .};
  373.  
  374. */
  375.  
  376. /*
  377. FUNCTION
  378.     The HOWTO Macro
  379.  
  380. DESCRIPTION
  381.     The HOWTO define is horrible and will go away.
  382.  
  383.  
  384. .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
  385. .  {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
  386.  
  387. DESCRIPTION
  388.     And will be replaced with the totally magic way. But for the
  389.     moment, we are compatible, so do it this way.
  390.  
  391.  
  392. .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
  393. .
  394. DESCRIPTION
  395.     Helper routine to turn a symbol into a relocation value.
  396.  
  397. .#define HOWTO_PREPARE(relocation, symbol)      \
  398. .  {                                            \
  399. .  if (symbol != (asymbol *)NULL) {             \
  400. .    if (bfd_is_com_section (symbol->section)) { \
  401. .      relocation = 0;                          \
  402. .    }                                          \
  403. .    else {                                     \
  404. .      relocation = symbol->value;              \
  405. .    }                                          \
  406. .  }                                            \
  407. .}
  408.  
  409. */
  410.  
  411. /*
  412. FUNCTION
  413.     bfd_get_reloc_size
  414.  
  415. SYNOPSIS
  416.     int bfd_get_reloc_size (const reloc_howto_type *);
  417.  
  418. DESCRIPTION
  419.     For a reloc_howto_type that operates on a fixed number of bytes,
  420.     this returns the number of bytes operated on.
  421.  */
  422.  
  423. int
  424. bfd_get_reloc_size (howto)
  425.      const reloc_howto_type *howto;
  426. {
  427.   switch (howto->size)
  428.     {
  429.     case 0: return 1;
  430.     case 1: return 2;
  431.     case 2: return 4;
  432.     case 3: return 0;
  433.     case 4: return 8;
  434.     case -2: return 4;
  435.     default: abort ();
  436.     }
  437. }
  438.  
  439. /*
  440. TYPEDEF
  441.     arelent_chain
  442.  
  443. DESCRIPTION
  444.  
  445.     How relocs are tied together in an <<asection>>:
  446.  
  447. .typedef struct relent_chain {
  448. .  arelent relent;
  449. .  struct   relent_chain *next;
  450. .} arelent_chain;
  451.  
  452. */
  453.  
  454.  
  455.  
  456. /*
  457. FUNCTION
  458.     bfd_perform_relocation
  459.  
  460. SYNOPSIS
  461.     bfd_reloc_status_type
  462.                 bfd_perform_relocation
  463.                         (bfd *abfd,
  464.                          arelent *reloc_entry,
  465.                          PTR data,
  466.                          asection *input_section,
  467.                          bfd *output_bfd,
  468.              char **error_message);
  469.  
  470. DESCRIPTION
  471.     If @var{output_bfd} is supplied to this function, the
  472.     generated image will be relocatable; the relocations are
  473.     copied to the output file after they have been changed to
  474.     reflect the new state of the world. There are two ways of
  475.     reflecting the results of partial linkage in an output file:
  476.     by modifying the output data in place, and by modifying the
  477.     relocation record.  Some native formats (e.g., basic a.out and
  478.     basic coff) have no way of specifying an addend in the
  479.     relocation type, so the addend has to go in the output data.
  480.     This is no big deal since in these formats the output data
  481.     slot will always be big enough for the addend. Complex reloc
  482.     types with addends were invented to solve just this problem.
  483.     The @var{error_message} argument is set to an error message if
  484.     this return @code{bfd_reloc_dangerous}.
  485.  
  486. */
  487.  
  488.  
  489. bfd_reloc_status_type
  490. bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
  491.             error_message)
  492.      bfd *abfd;
  493.      arelent *reloc_entry;
  494.      PTR data;
  495.      asection *input_section;
  496.      bfd *output_bfd;
  497.      char **error_message;
  498. {
  499.   bfd_vma relocation;
  500.   bfd_reloc_status_type flag = bfd_reloc_ok;
  501.   bfd_size_type addr = reloc_entry->address;
  502.   bfd_vma output_base = 0;
  503.   const reloc_howto_type *howto = reloc_entry->howto;
  504.   asection *reloc_target_output_section;
  505.   asymbol *symbol;
  506.  
  507.   symbol = *(reloc_entry->sym_ptr_ptr);
  508.   if (bfd_is_abs_section (symbol->section)
  509.       && output_bfd != (bfd *) NULL)
  510.     {
  511.       reloc_entry->address += input_section->output_offset;
  512.       return bfd_reloc_ok;
  513.     }
  514.  
  515.   /* If we are not producing relocateable output, return an error if
  516.      the symbol is not defined.  An undefined weak symbol is
  517.      considered to have a value of zero (SVR4 ABI, p. 4-27).  */
  518.   if (bfd_is_und_section (symbol->section)
  519.       && (symbol->flags & BSF_WEAK) == 0
  520.       && output_bfd == (bfd *) NULL)
  521.     flag = bfd_reloc_undefined;
  522.  
  523.   /* If there is a function supplied to handle this relocation type,
  524.      call it.  It'll return `bfd_reloc_continue' if further processing
  525.      can be done.  */
  526.   if (howto->special_function)
  527.     {
  528.       bfd_reloc_status_type cont;
  529.       cont = howto->special_function (abfd, reloc_entry, symbol, data,
  530.                       input_section, output_bfd,
  531.                       error_message);
  532.       if (cont != bfd_reloc_continue)
  533.     return cont;
  534.     }
  535.  
  536.   /* Is the address of the relocation really within the section?  */
  537.   if (reloc_entry->address > input_section->_cooked_size)
  538.     return bfd_reloc_outofrange;
  539.  
  540.   /* Work out which section the relocation is targetted at and the
  541.      initial relocation command value.  */
  542.  
  543.   /* Get symbol value.  (Common symbols are special.)  */
  544.   if (bfd_is_com_section (symbol->section))
  545.     relocation = 0;
  546.   else
  547.     relocation = symbol->value;
  548.  
  549.  
  550.   reloc_target_output_section = symbol->section->output_section;
  551.  
  552.   /* Convert input-section-relative symbol value to absolute.  */
  553.   if (output_bfd && howto->partial_inplace == false)
  554.     output_base = 0;
  555.   else
  556.     output_base = reloc_target_output_section->vma;
  557.  
  558.   relocation += output_base + symbol->section->output_offset;
  559.  
  560.   /* Add in supplied addend.  */
  561.   relocation += reloc_entry->addend;
  562.  
  563.   /* Here the variable relocation holds the final address of the
  564.      symbol we are relocating against, plus any addend.  */
  565.  
  566.   if (howto->pc_relative == true)
  567.     {
  568.       /* This is a PC relative relocation.  We want to set RELOCATION
  569.      to the distance between the address of the symbol and the
  570.      location.  RELOCATION is already the address of the symbol.
  571.  
  572.      We start by subtracting the address of the section containing
  573.      the location.
  574.  
  575.      If pcrel_offset is set, we must further subtract the position
  576.      of the location within the section.  Some targets arrange for
  577.      the addend to be the negative of the position of the location
  578.      within the section; for example, i386-aout does this.  For
  579.      i386-aout, pcrel_offset is false.  Some other targets do not
  580.      include the position of the location; for example, m88kbcs,
  581.      or ELF.  For those targets, pcrel_offset is true.
  582.  
  583.      If we are producing relocateable output, then we must ensure
  584.      that this reloc will be correctly computed when the final
  585.      relocation is done.  If pcrel_offset is false we want to wind
  586.      up with the negative of the location within the section,
  587.      which means we must adjust the existing addend by the change
  588.      in the location within the section.  If pcrel_offset is true
  589.      we do not want to adjust the existing addend at all.
  590.  
  591.      FIXME: This seems logical to me, but for the case of
  592.      producing relocateable output it is not what the code
  593.      actually does.  I don't want to change it, because it seems
  594.      far too likely that something will break.  */
  595.  
  596.       relocation -=
  597.     input_section->output_section->vma + input_section->output_offset;
  598.  
  599.       if (howto->pcrel_offset == true)
  600.     relocation -= reloc_entry->address;
  601.     }
  602.  
  603.   if (output_bfd != (bfd *) NULL)
  604.     {
  605.       if (howto->partial_inplace == false)
  606.     {
  607.       /* This is a partial relocation, and we want to apply the relocation
  608.          to the reloc entry rather than the raw data. Modify the reloc
  609.          inplace to reflect what we now know.  */
  610.       reloc_entry->addend = relocation;
  611.       reloc_entry->address += input_section->output_offset;
  612.       return flag;
  613.     }
  614.       else
  615.     {
  616.       /* This is a partial relocation, but inplace, so modify the
  617.          reloc record a bit.
  618.  
  619.          If we've relocated with a symbol with a section, change
  620.          into a ref to the section belonging to the symbol.  */
  621.  
  622.       reloc_entry->address += input_section->output_offset;
  623.  
  624.       /* WTF?? */
  625.       if (abfd->xvec->flavour == bfd_target_coff_flavour
  626.           && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0
  627.           && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
  628.           && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
  629.         {
  630. #if 1
  631.           /* For m68k-coff, the addend was being subtracted twice during
  632.          relocation with -r.  Removing the line below this comment
  633.          fixes that problem; see PR 2953.
  634.  
  635. However, Ian wrote the following, regarding removing the line below,
  636. which explains why it is still enabled:  --djm
  637.  
  638. If you put a patch like that into BFD you need to check all the COFF
  639. linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
  640. SCO); see coff_i386_reloc in coff-i386.c where I worked around the
  641. problem in a different way.  There may very well be a reason that the
  642. code works as it does.
  643.  
  644. Hmmm.  The first obvious point is that bfd_perform_relocation should
  645. not have any tests that depend upon the flavour.  It's seem like
  646. entirely the wrong place for such a thing.  The second obvious point
  647. is that the current code ignores the reloc addend when producing
  648. relocateable output for COFF.  That's peculiar.  In fact, I really
  649. have no idea what the point of the line you want to remove is.
  650.  
  651. A typical COFF reloc subtracts the old value of the symbol and adds in
  652. the new value to the location in the object file (if it's a pc
  653. relative reloc it adds the difference between the symbol value and the
  654. location).  When relocating we need to preserve that property.
  655.  
  656. BFD handles this by setting the addend to the negative of the old
  657. value of the symbol.  Unfortunately it handles common symbols in a
  658. non-standard way (it doesn't subtract the old value) but that's a
  659. different story (we can't change it without losing backward
  660. compatibility with old object files) (coff-i386 does subtract the old
  661. value, to be compatible with existing coff-i386 targets, like SCO).
  662.  
  663. So everything works fine when not producing relocateable output.  When
  664. we are producing relocateable output, logically we should do exactly
  665. what we do when not producing relocateable output.  Therefore, your
  666. patch is correct.  In fact, it should probably always just set
  667. reloc_entry->addend to 0 for all cases, since it is, in fact, going to
  668. add the value into the object file.  This won't hurt the COFF code,
  669. which doesn't use the addend; I'm not sure what it will do to other
  670. formats (the thing to check for would be whether any formats both use
  671. the addend and set partial_inplace).
  672.  
  673. When I wanted to make coff-i386 produce relocateable output, I ran
  674. into the problem that you are running into: I wanted to remove that
  675. line.  Rather than risk it, I made the coff-i386 relocs use a special
  676. function; it's coff_i386_reloc in coff-i386.c.  The function
  677. specifically adds the addend field into the object file, knowing that
  678. bfd_perform_relocation is not going to.  If you remove that line, then
  679. coff-i386.c will wind up adding the addend field in twice.  It's
  680. trivial to fix; it just needs to be done.
  681.  
  682. The problem with removing the line is just that it may break some
  683. working code.  With BFD it's hard to be sure of anything.  The right
  684. way to deal with this is simply to build and test at least all the
  685. supported COFF targets.  It should be straightforward if time and disk
  686. space consuming.  For each target:
  687.     1) build the linker
  688.     2) generate some executable, and link it using -r (I would
  689.        probably use paranoia.o and link against newlib/libc.a, which
  690.        for all the supported targets would be available in
  691.        /usr/cygnus/progressive/H-host/target/lib/libc.a).
  692.     3) make the change to reloc.c
  693.     4) rebuild the linker
  694.     5) repeat step 2
  695.     6) if the resulting object files are the same, you have at least
  696.        made it no worse
  697.     7) if they are different you have to figure out which version is
  698.        right
  699. */
  700.           relocation -= reloc_entry->addend;
  701. #endif
  702.           reloc_entry->addend = 0;
  703.         }
  704.       else
  705.         {
  706.           reloc_entry->addend = relocation;
  707.         }
  708.     }
  709.     }
  710.   else
  711.     {
  712.       reloc_entry->addend = 0;
  713.     }
  714.  
  715.   /* FIXME: This overflow checking is incomplete, because the value
  716.      might have overflowed before we get here.  For a correct check we
  717.      need to compute the value in a size larger than bitsize, but we
  718.      can't reasonably do that for a reloc the same size as a host
  719.      machine word.
  720.      FIXME: We should also do overflow checking on the result after
  721.      adding in the value contained in the object file.  */
  722.   if (howto->complain_on_overflow != complain_overflow_dont)
  723.     {
  724.       bfd_vma check;
  725.  
  726.       /* Get the value that will be used for the relocation, but
  727.      starting at bit position zero.  */
  728.       if (howto->rightshift > howto->bitpos)
  729.     check = relocation >> (howto->rightshift - howto->bitpos);
  730.       else
  731.     check = relocation << (howto->bitpos - howto->rightshift);
  732.       switch (howto->complain_on_overflow)
  733.     {
  734.     case complain_overflow_signed:
  735.       {
  736.         /* Assumes two's complement.  */
  737.         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
  738.         bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
  739.  
  740.         /* The above right shift is incorrect for a signed value.
  741.            Fix it up by forcing on the upper bits.  */
  742.         if (howto->rightshift > howto->bitpos
  743.         && (bfd_signed_vma) relocation < 0)
  744.           check |= ((bfd_vma) - 1
  745.             & ~((bfd_vma) - 1
  746.                 >> (howto->rightshift - howto->bitpos)));
  747.         if ((bfd_signed_vma) check > reloc_signed_max
  748.         || (bfd_signed_vma) check < reloc_signed_min)
  749.           flag = bfd_reloc_overflow;
  750.       }
  751.       break;
  752.     case complain_overflow_unsigned:
  753.       {
  754.         /* Assumes two's complement.  This expression avoids
  755.            overflow if howto->bitsize is the number of bits in
  756.            bfd_vma.  */
  757.         bfd_vma reloc_unsigned_max =
  758.         (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
  759.  
  760.         if ((bfd_vma) check > reloc_unsigned_max)
  761.           flag = bfd_reloc_overflow;
  762.       }
  763.       break;
  764.     case complain_overflow_bitfield:
  765.       {
  766.         /* Assumes two's complement.  This expression avoids
  767.            overflow if howto->bitsize is the number of bits in
  768.            bfd_vma.  */
  769.         bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
  770.  
  771.         if (((bfd_vma) check & ~reloc_bits) != 0
  772.         && ((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
  773.           {
  774.         /* The above right shift is incorrect for a signed
  775.            value.  See if turning on the upper bits fixes the
  776.            overflow.  */
  777.         if (howto->rightshift > howto->bitpos
  778.             && (bfd_signed_vma) relocation < 0)
  779.           {
  780.             check |= ((bfd_vma) - 1
  781.                   & ~((bfd_vma) - 1
  782.                   >> (howto->rightshift - howto->bitpos)));
  783.             if (((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
  784.               flag = bfd_reloc_overflow;
  785.           }
  786.         else
  787.           flag = bfd_reloc_overflow;
  788.           }
  789.       }
  790.       break;
  791.     default:
  792.       abort ();
  793.     }
  794.     }
  795.  
  796.   /*
  797.     Either we are relocating all the way, or we don't want to apply
  798.     the relocation to the reloc entry (probably because there isn't
  799.     any room in the output format to describe addends to relocs)
  800.     */
  801.  
  802.   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
  803.      (OSF version 1.3, compiler version 3.11).  It miscompiles the
  804.      following program:
  805.  
  806.      struct str
  807.      {
  808.        unsigned int i0;
  809.      } s = { 0 };
  810.  
  811.      int
  812.      main ()
  813.      {
  814.        unsigned long x;
  815.  
  816.        x = 0x100000000;
  817.        x <<= (unsigned long) s.i0;
  818.        if (x == 0)
  819.      printf ("failed\n");
  820.        else
  821.      printf ("succeeded (%lx)\n", x);
  822.      }
  823.      */
  824.  
  825.   relocation >>= (bfd_vma) howto->rightshift;
  826.  
  827.   /* Shift everything up to where it's going to be used */
  828.  
  829.   relocation <<= (bfd_vma) howto->bitpos;
  830.  
  831.   /* Wait for the day when all have the mask in them */
  832.  
  833.   /* What we do:
  834.      i instruction to be left alone
  835.      o offset within instruction
  836.      r relocation offset to apply
  837.      S src mask
  838.      D dst mask
  839.      N ~dst mask
  840.      A part 1
  841.      B part 2
  842.      R result
  843.  
  844.      Do this:
  845.      i i i i i o o o o o        from bfd_get<size>
  846.      and           S S S S S    to get the size offset we want
  847.      +   r r r r r r r r r r  to get the final value to place
  848.      and           D D D D D  to chop to right size
  849.      -----------------------
  850.      A A A A A
  851.      And this:
  852.      ...   i i i i i o o o o o  from bfd_get<size>
  853.      and   N N N N N            get instruction
  854.      -----------------------
  855.      ...   B B B B B
  856.  
  857.      And then:
  858.      B B B B B
  859.      or              A A A A A
  860.      -----------------------
  861.      R R R R R R R R R R        put into bfd_put<size>
  862.      */
  863.  
  864. #define DOIT(x) \
  865.   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
  866.  
  867.   switch (howto->size)
  868.     {
  869.     case 0:
  870.       {
  871.     char x = bfd_get_8 (abfd, (char *) data + addr);
  872.     DOIT (x);
  873.     bfd_put_8 (abfd, x, (unsigned char *) data + addr);
  874.       }
  875.       break;
  876.  
  877.     case 1:
  878.       if (relocation)
  879.     {
  880.       short x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
  881.       DOIT (x);
  882.       bfd_put_16 (abfd, x, (unsigned char *) data + addr);
  883.     }
  884.       break;
  885.     case 2:
  886.       if (relocation)
  887.     {
  888.       long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
  889.       DOIT (x);
  890.       bfd_put_32 (abfd, x, (bfd_byte *) data + addr);
  891.     }
  892.       break;
  893.     case -2:
  894.       {
  895.     long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
  896.     relocation = -relocation;
  897.     DOIT (x);
  898.     bfd_put_32 (abfd, x, (bfd_byte *) data + addr);
  899.       }
  900.       break;
  901.  
  902.     case 3:
  903.       /* Do nothing */
  904.       break;
  905.  
  906.     case 4:
  907. #ifdef BFD64
  908.       if (relocation)
  909.     {
  910.       bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + addr);
  911.       DOIT (x);
  912.       bfd_put_64 (abfd, x, (bfd_byte *) data + addr);
  913.     }
  914. #else
  915.       abort ();
  916. #endif
  917.       break;
  918.     default:
  919.       return bfd_reloc_other;
  920.     }
  921.  
  922.   return flag;
  923. }
  924.  
  925. /*
  926. FUNCTION
  927.     bfd_install_relocation
  928.  
  929. SYNOPSIS
  930.     bfd_reloc_status_type
  931.                 bfd_install_relocation
  932.                         (bfd *abfd,
  933.                          arelent *reloc_entry,
  934.                          PTR data, bfd_vma data_start,
  935.                          asection *input_section,
  936.              char **error_message);
  937.  
  938. DESCRIPTION
  939.     This looks remarkably like <<bfd_perform_relocation>>, except it
  940.     does not expect that the section contents have been filled in.
  941.     I.e., it's suitable for use when creating, rather than applying
  942.     a relocation.
  943.  
  944.     For now, this function should be considered reserved for the
  945.     assembler.
  946.  
  947. */
  948.  
  949.  
  950. bfd_reloc_status_type
  951. bfd_install_relocation (abfd, reloc_entry, data_start, data_start_offset,
  952.             input_section, error_message)
  953.      bfd *abfd;
  954.      arelent *reloc_entry;
  955.      PTR data_start;
  956.      bfd_vma data_start_offset;
  957.      asection *input_section;
  958.      char **error_message;
  959. {
  960.   bfd_vma relocation;
  961.   bfd_reloc_status_type flag = bfd_reloc_ok;
  962.   bfd_size_type addr = reloc_entry->address;
  963.   bfd_vma output_base = 0;
  964.   const reloc_howto_type *howto = reloc_entry->howto;
  965.   asection *reloc_target_output_section;
  966.   asymbol *symbol;
  967.   bfd_byte *data;
  968.  
  969.   symbol = *(reloc_entry->sym_ptr_ptr);
  970.   if (bfd_is_abs_section (symbol->section))
  971.     {
  972.       reloc_entry->address += input_section->output_offset;
  973.       return bfd_reloc_ok;
  974.     }
  975.  
  976.   /* If there is a function supplied to handle this relocation type,
  977.      call it.  It'll return `bfd_reloc_continue' if further processing
  978.      can be done.  */
  979.   if (howto->special_function)
  980.     {
  981.       bfd_reloc_status_type cont;
  982.       /* XXX - The special_function calls haven't been fixed up to deal
  983.      with creating new relocations and section contents.  */
  984.       cont = howto->special_function (abfd, reloc_entry, symbol,
  985.                       /* XXX - Non-portable! */
  986.                       ((bfd_byte *) data_start
  987.                        - data_start_offset),
  988.                       input_section, abfd, error_message);
  989.       if (cont != bfd_reloc_continue)
  990.     return cont;
  991.     }
  992.  
  993.   /* Is the address of the relocation really within the section?  */
  994.   if (reloc_entry->address > input_section->_cooked_size)
  995.     return bfd_reloc_outofrange;
  996.  
  997.   /* Work out which section the relocation is targetted at and the
  998.      initial relocation command value.  */
  999.  
  1000.   /* Get symbol value.  (Common symbols are special.)  */
  1001.   if (bfd_is_com_section (symbol->section))
  1002.     relocation = 0;
  1003.   else
  1004.     relocation = symbol->value;
  1005.  
  1006.  
  1007.   reloc_target_output_section = symbol->section->output_section;
  1008.  
  1009.   /* Convert input-section-relative symbol value to absolute.  */
  1010.   if (howto->partial_inplace == false)
  1011.     output_base = 0;
  1012.   else
  1013.     output_base = reloc_target_output_section->vma;
  1014.  
  1015.   relocation += output_base + symbol->section->output_offset;
  1016.  
  1017.   /* Add in supplied addend.  */
  1018.   relocation += reloc_entry->addend;
  1019.  
  1020.   /* Here the variable relocation holds the final address of the
  1021.      symbol we are relocating against, plus any addend.  */
  1022.  
  1023.   if (howto->pc_relative == true)
  1024.     {
  1025.       /* This is a PC relative relocation.  We want to set RELOCATION
  1026.      to the distance between the address of the symbol and the
  1027.      location.  RELOCATION is already the address of the symbol.
  1028.  
  1029.      We start by subtracting the address of the section containing
  1030.      the location.
  1031.  
  1032.      If pcrel_offset is set, we must further subtract the position
  1033.      of the location within the section.  Some targets arrange for
  1034.      the addend to be the negative of the position of the location
  1035.      within the section; for example, i386-aout does this.  For
  1036.      i386-aout, pcrel_offset is false.  Some other targets do not
  1037.      include the position of the location; for example, m88kbcs,
  1038.      or ELF.  For those targets, pcrel_offset is true.
  1039.  
  1040.      If we are producing relocateable output, then we must ensure
  1041.      that this reloc will be correctly computed when the final
  1042.      relocation is done.  If pcrel_offset is false we want to wind
  1043.      up with the negative of the location within the section,
  1044.      which means we must adjust the existing addend by the change
  1045.      in the location within the section.  If pcrel_offset is true
  1046.      we do not want to adjust the existing addend at all.
  1047.  
  1048.      FIXME: This seems logical to me, but for the case of
  1049.      producing relocateable output it is not what the code
  1050.      actually does.  I don't want to change it, because it seems
  1051.      far too likely that something will break.  */
  1052.  
  1053.       relocation -=
  1054.     input_section->output_section->vma + input_section->output_offset;
  1055.  
  1056.       if (howto->pcrel_offset == true && howto->partial_inplace == true)
  1057.     relocation -= reloc_entry->address;
  1058.     }
  1059.  
  1060.   if (howto->partial_inplace == false)
  1061.     {
  1062.       /* This is a partial relocation, and we want to apply the relocation
  1063.      to the reloc entry rather than the raw data. Modify the reloc
  1064.      inplace to reflect what we now know.  */
  1065.       reloc_entry->addend = relocation;
  1066.       reloc_entry->address += input_section->output_offset;
  1067.       return flag;
  1068.     }
  1069.   else
  1070.     {
  1071.       /* This is a partial relocation, but inplace, so modify the
  1072.      reloc record a bit.
  1073.      
  1074.      If we've relocated with a symbol with a section, change
  1075.      into a ref to the section belonging to the symbol.  */
  1076.       
  1077.       reloc_entry->address += input_section->output_offset;
  1078.       
  1079.       /* WTF?? */
  1080.       if (abfd->xvec->flavour == bfd_target_coff_flavour
  1081.       && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0
  1082.       && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
  1083.       && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
  1084.     {
  1085. #if 1
  1086. /* For m68k-coff, the addend was being subtracted twice during
  1087.    relocation with -r.  Removing the line below this comment
  1088.    fixes that problem; see PR 2953.
  1089.          
  1090. However, Ian wrote the following, regarding removing the line below,
  1091. which explains why it is still enabled:  --djm
  1092.          
  1093. If you put a patch like that into BFD you need to check all the COFF
  1094. linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
  1095. SCO); see coff_i386_reloc in coff-i386.c where I worked around the
  1096. problem in a different way.  There may very well be a reason that the
  1097. code works as it does.
  1098.  
  1099. Hmmm.  The first obvious point is that bfd_install_relocation should
  1100. not have any tests that depend upon the flavour.  It's seem like
  1101. entirely the wrong place for such a thing.  The second obvious point
  1102. is that the current code ignores the reloc addend when producing
  1103. relocateable output for COFF.  That's peculiar.  In fact, I really
  1104. have no idea what the point of the line you want to remove is.
  1105.  
  1106. A typical COFF reloc subtracts the old value of the symbol and adds in
  1107. the new value to the location in the object file (if it's a pc
  1108. relative reloc it adds the difference between the symbol value and the
  1109. location).  When relocating we need to preserve that property.
  1110.  
  1111. BFD handles this by setting the addend to the negative of the old
  1112. value of the symbol.  Unfortunately it handles common symbols in a
  1113. non-standard way (it doesn't subtract the old value) but that's a
  1114. different story (we can't change it without losing backward
  1115. compatibility with old object files) (coff-i386 does subtract the old
  1116. value, to be compatible with existing coff-i386 targets, like SCO).
  1117.  
  1118. So everything works fine when not producing relocateable output.  When
  1119. we are producing relocateable output, logically we should do exactly
  1120. what we do when not producing relocateable output.  Therefore, your
  1121. patch is correct.  In fact, it should probably always just set
  1122. reloc_entry->addend to 0 for all cases, since it is, in fact, going to
  1123. add the value into the object file.  This won't hurt the COFF code,
  1124. which doesn't use the addend; I'm not sure what it will do to other
  1125. formats (the thing to check for would be whether any formats both use
  1126. the addend and set partial_inplace).
  1127.  
  1128. When I wanted to make coff-i386 produce relocateable output, I ran
  1129. into the problem that you are running into: I wanted to remove that
  1130. line.  Rather than risk it, I made the coff-i386 relocs use a special
  1131. function; it's coff_i386_reloc in coff-i386.c.  The function
  1132. specifically adds the addend field into the object file, knowing that
  1133. bfd_install_relocation is not going to.  If you remove that line, then
  1134. coff-i386.c will wind up adding the addend field in twice.  It's
  1135. trivial to fix; it just needs to be done.
  1136.  
  1137. The problem with removing the line is just that it may break some
  1138. working code.  With BFD it's hard to be sure of anything.  The right
  1139. way to deal with this is simply to build and test at least all the
  1140. supported COFF targets.  It should be straightforward if time and disk
  1141. space consuming.  For each target:
  1142.     1) build the linker
  1143.     2) generate some executable, and link it using -r (I would
  1144.        probably use paranoia.o and link against newlib/libc.a, which
  1145.        for all the supported targets would be available in
  1146.        /usr/cygnus/progressive/H-host/target/lib/libc.a).
  1147.     3) make the change to reloc.c
  1148.     4) rebuild the linker
  1149.     5) repeat step 2
  1150.     6) if the resulting object files are the same, you have at least
  1151.        made it no worse
  1152.     7) if they are different you have to figure out which version is
  1153.        right
  1154. */
  1155.       relocation -= reloc_entry->addend;
  1156. #endif
  1157.       reloc_entry->addend = 0;
  1158.     }
  1159.       else
  1160.     {
  1161.       reloc_entry->addend = relocation;
  1162.     }
  1163.     }
  1164.  
  1165.   /* FIXME: This overflow checking is incomplete, because the value
  1166.      might have overflowed before we get here.  For a correct check we
  1167.      need to compute the value in a size larger than bitsize, but we
  1168.      can't reasonably do that for a reloc the same size as a host
  1169.      machine word.
  1170.  
  1171.      FIXME: We should also do overflow checking on the result after
  1172.      adding in the value contained in the object file.  */
  1173.   if (howto->complain_on_overflow != complain_overflow_dont)
  1174.     {
  1175.       bfd_vma check;
  1176.  
  1177.       /* Get the value that will be used for the relocation, but
  1178.      starting at bit position zero.  */
  1179.       if (howto->rightshift > howto->bitpos)
  1180.     check = relocation >> (howto->rightshift - howto->bitpos);
  1181.       else
  1182.     check = relocation << (howto->bitpos - howto->rightshift);
  1183.       switch (howto->complain_on_overflow)
  1184.     {
  1185.     case complain_overflow_signed:
  1186.       {
  1187.         /* Assumes two's complement.  */
  1188.         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
  1189.         bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
  1190.  
  1191.         /* The above right shift is incorrect for a signed value.
  1192.            Fix it up by forcing on the upper bits.  */
  1193.         if (howto->rightshift > howto->bitpos
  1194.         && (bfd_signed_vma) relocation < 0)
  1195.           check |= ((bfd_vma) - 1
  1196.             & ~((bfd_vma) - 1
  1197.                 >> (howto->rightshift - howto->bitpos)));
  1198.         if ((bfd_signed_vma) check > reloc_signed_max
  1199.         || (bfd_signed_vma) check < reloc_signed_min)
  1200.           flag = bfd_reloc_overflow;
  1201.       }
  1202.       break;
  1203.     case complain_overflow_unsigned:
  1204.       {
  1205.         /* Assumes two's complement.  This expression avoids
  1206.            overflow if howto->bitsize is the number of bits in
  1207.            bfd_vma.  */
  1208.         bfd_vma reloc_unsigned_max =
  1209.         (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
  1210.  
  1211.         if ((bfd_vma) check > reloc_unsigned_max)
  1212.           flag = bfd_reloc_overflow;
  1213.       }
  1214.       break;
  1215.     case complain_overflow_bitfield:
  1216.       {
  1217.         /* Assumes two's complement.  This expression avoids
  1218.            overflow if howto->bitsize is the number of bits in
  1219.            bfd_vma.  */
  1220.         bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
  1221.  
  1222.         if (((bfd_vma) check & ~reloc_bits) != 0
  1223.         && ((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
  1224.           {
  1225.         /* The above right shift is incorrect for a signed
  1226.            value.  See if turning on the upper bits fixes the
  1227.            overflow.  */
  1228.         if (howto->rightshift > howto->bitpos
  1229.             && (bfd_signed_vma) relocation < 0)
  1230.           {
  1231.             check |= ((bfd_vma) - 1
  1232.                   & ~((bfd_vma) - 1
  1233.                   >> (howto->rightshift - howto->bitpos)));
  1234.             if (((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
  1235.               flag = bfd_reloc_overflow;
  1236.           }
  1237.         else
  1238.           flag = bfd_reloc_overflow;
  1239.           }
  1240.       }
  1241.       break;
  1242.     default:
  1243.       abort ();
  1244.     }
  1245.     }
  1246.  
  1247.   /*
  1248.     Either we are relocating all the way, or we don't want to apply
  1249.     the relocation to the reloc entry (probably because there isn't
  1250.     any room in the output format to describe addends to relocs)
  1251.     */
  1252.  
  1253.   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
  1254.      (OSF version 1.3, compiler version 3.11).  It miscompiles the
  1255.      following program:
  1256.  
  1257.      struct str
  1258.      {
  1259.        unsigned int i0;
  1260.      } s = { 0 };
  1261.  
  1262.      int
  1263.      main ()
  1264.      {
  1265.        unsigned long x;
  1266.  
  1267.        x = 0x100000000;
  1268.        x <<= (unsigned long) s.i0;
  1269.        if (x == 0)
  1270.      printf ("failed\n");
  1271.        else
  1272.      printf ("succeeded (%lx)\n", x);
  1273.      }
  1274.      */
  1275.  
  1276.   relocation >>= (bfd_vma) howto->rightshift;
  1277.  
  1278.   /* Shift everything up to where it's going to be used */
  1279.  
  1280.   relocation <<= (bfd_vma) howto->bitpos;
  1281.  
  1282.   /* Wait for the day when all have the mask in them */
  1283.  
  1284.   /* What we do:
  1285.      i instruction to be left alone
  1286.      o offset within instruction
  1287.      r relocation offset to apply
  1288.      S src mask
  1289.      D dst mask
  1290.      N ~dst mask
  1291.      A part 1
  1292.      B part 2
  1293.      R result
  1294.  
  1295.      Do this:
  1296.      i i i i i o o o o o        from bfd_get<size>
  1297.      and           S S S S S    to get the size offset we want
  1298.      +   r r r r r r r r r r  to get the final value to place
  1299.      and           D D D D D  to chop to right size
  1300.      -----------------------
  1301.      A A A A A
  1302.      And this:
  1303.      ...   i i i i i o o o o o  from bfd_get<size>
  1304.      and   N N N N N            get instruction
  1305.      -----------------------
  1306.      ...   B B B B B
  1307.  
  1308.      And then:
  1309.      B B B B B
  1310.      or              A A A A A
  1311.      -----------------------
  1312.      R R R R R R R R R R        put into bfd_put<size>
  1313.      */
  1314.  
  1315. #define DOIT(x) \
  1316.   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
  1317.  
  1318.   data = (bfd_byte *) data_start + (addr - data_start_offset);
  1319.  
  1320.   switch (howto->size)
  1321.     {
  1322.     case 0:
  1323.       {
  1324.     char x = bfd_get_8 (abfd, (char *) data);
  1325.     DOIT (x);
  1326.     bfd_put_8 (abfd, x, (unsigned char *) data);
  1327.       }
  1328.       break;
  1329.  
  1330.     case 1:
  1331.       if (relocation)
  1332.     {
  1333.       short x = bfd_get_16 (abfd, (bfd_byte *) data);
  1334.       DOIT (x);
  1335.       bfd_put_16 (abfd, x, (unsigned char *) data);
  1336.     }
  1337.       break;
  1338.     case 2:
  1339.       if (relocation)
  1340.     {
  1341.       long x = bfd_get_32 (abfd, (bfd_byte *) data);
  1342.       DOIT (x);
  1343.       bfd_put_32 (abfd, x, (bfd_byte *) data);
  1344.     }
  1345.       break;
  1346.     case -2:
  1347.       {
  1348.     long x = bfd_get_32 (abfd, (bfd_byte *) data);
  1349.     relocation = -relocation;
  1350.     DOIT (x);
  1351.     bfd_put_32 (abfd, x, (bfd_byte *) data);
  1352.       }
  1353.       break;
  1354.  
  1355.     case 3:
  1356.       /* Do nothing */
  1357.       break;
  1358.  
  1359.     case 4:
  1360.       if (relocation)
  1361.     {
  1362.       bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data);
  1363.       DOIT (x);
  1364.       bfd_put_64 (abfd, x, (bfd_byte *) data);
  1365.     }
  1366.       break;
  1367.     default:
  1368.       return bfd_reloc_other;
  1369.     }
  1370.  
  1371.   return flag;
  1372. }
  1373.  
  1374. /* This relocation routine is used by some of the backend linkers.
  1375.    They do not construct asymbol or arelent structures, so there is no
  1376.    reason for them to use bfd_perform_relocation.  Also,
  1377.    bfd_perform_relocation is so hacked up it is easier to write a new
  1378.    function than to try to deal with it.
  1379.  
  1380.    This routine does a final relocation.  It should not be used when
  1381.    generating relocateable output.
  1382.  
  1383.    FIXME: This routine ignores any special_function in the HOWTO,
  1384.    since the existing special_function values have been written for
  1385.    bfd_perform_relocation.
  1386.  
  1387.    HOWTO is the reloc howto information.
  1388.    INPUT_BFD is the BFD which the reloc applies to.
  1389.    INPUT_SECTION is the section which the reloc applies to.
  1390.    CONTENTS is the contents of the section.
  1391.    ADDRESS is the address of the reloc within INPUT_SECTION.
  1392.    VALUE is the value of the symbol the reloc refers to.
  1393.    ADDEND is the addend of the reloc.  */
  1394.  
  1395. bfd_reloc_status_type
  1396. _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
  1397.               value, addend)
  1398.      const reloc_howto_type *howto;
  1399.      bfd *input_bfd;
  1400.      asection *input_section;
  1401.      bfd_byte *contents;
  1402.      bfd_vma address;
  1403.      bfd_vma value;
  1404.      bfd_vma addend;
  1405. {
  1406.   bfd_vma relocation;
  1407.  
  1408.   /* Sanity check the address.  */
  1409.   if (address > input_section->_cooked_size)
  1410.     return bfd_reloc_outofrange;
  1411.  
  1412.   /* This function assumes that we are dealing with a basic relocation
  1413.      against a symbol.  We want to compute the value of the symbol to
  1414.      relocate to.  This is just VALUE, the value of the symbol, plus
  1415.      ADDEND, any addend associated with the reloc.  */
  1416.   relocation = value + addend;
  1417.  
  1418.   /* If the relocation is PC relative, we want to set RELOCATION to
  1419.      the distance between the symbol (currently in RELOCATION) and the
  1420.      location we are relocating.  Some targets (e.g., i386-aout)
  1421.      arrange for the contents of the section to be the negative of the
  1422.      offset of the location within the section; for such targets
  1423.      pcrel_offset is false.  Other targets (e.g., m88kbcs or ELF)
  1424.      simply leave the contents of the section as zero; for such
  1425.      targets pcrel_offset is true.  If pcrel_offset is false we do not
  1426.      need to subtract out the offset of the location within the
  1427.      section (which is just ADDRESS).  */
  1428.   if (howto->pc_relative)
  1429.     {
  1430.       relocation -= (input_section->output_section->vma
  1431.              + input_section->output_offset);
  1432.       if (howto->pcrel_offset)
  1433.     relocation -= address;
  1434.     }
  1435.  
  1436.   return _bfd_relocate_contents (howto, input_bfd, relocation,
  1437.                  contents + address);
  1438. }
  1439.  
  1440. /* Relocate a given location using a given value and howto.  */
  1441.  
  1442. bfd_reloc_status_type
  1443. _bfd_relocate_contents (howto, input_bfd, relocation, location)
  1444.      const reloc_howto_type *howto;
  1445.      bfd *input_bfd;
  1446.      bfd_vma relocation;
  1447.      bfd_byte *location;
  1448. {
  1449.   int size;
  1450.   bfd_vma x;
  1451.   boolean overflow;
  1452.  
  1453.   /* If the size is negative, negate RELOCATION.  This isn't very
  1454.      general.  */
  1455.   if (howto->size < 0)
  1456.     relocation = -relocation;
  1457.  
  1458.   /* Get the value we are going to relocate.  */
  1459.   size = bfd_get_reloc_size (howto);
  1460.   switch (size)
  1461.     {
  1462.     default:
  1463.     case 0:
  1464.       abort ();
  1465.     case 1:
  1466.       x = bfd_get_8 (input_bfd, location);
  1467.       break;
  1468.     case 2:
  1469.       x = bfd_get_16 (input_bfd, location);
  1470.       break;
  1471.     case 4:
  1472.       x = bfd_get_32 (input_bfd, location);
  1473.       break;
  1474.     case 8:
  1475. #ifdef BFD64
  1476.       x = bfd_get_64 (input_bfd, location);
  1477. #else
  1478.       abort ();
  1479. #endif
  1480.       break;
  1481.     }
  1482.  
  1483.   /* Check for overflow.  FIXME: We may drop bits during the addition
  1484.      which we don't check for.  We must either check at every single
  1485.      operation, which would be tedious, or we must do the computations
  1486.      in a type larger than bfd_vma, which would be inefficient.  */
  1487.   overflow = false;
  1488.   if (howto->complain_on_overflow != complain_overflow_dont)
  1489.     {
  1490.       bfd_vma check;
  1491.       bfd_signed_vma signed_check;
  1492.       bfd_vma add;
  1493.       bfd_signed_vma signed_add;
  1494.  
  1495.       if (howto->rightshift == 0)
  1496.     {
  1497.       check = relocation;
  1498.       signed_check = (bfd_signed_vma) relocation;
  1499.     }
  1500.       else
  1501.     {
  1502.       /* Drop unwanted bits from the value we are relocating to.  */
  1503.       check = relocation >> howto->rightshift;
  1504.  
  1505.       /* If this is a signed value, the rightshift just dropped
  1506.          leading 1 bits (assuming twos complement).  */
  1507.       if ((bfd_signed_vma) relocation >= 0)
  1508.         signed_check = check;
  1509.       else
  1510.         signed_check = (check
  1511.                 | ((bfd_vma) - 1
  1512.                    & ~((bfd_vma) - 1 >> howto->rightshift)));
  1513.     }
  1514.  
  1515.       /* Get the value from the object file.  */
  1516.       add = x & howto->src_mask;
  1517.  
  1518.       /* Get the value from the object file with an appropriate sign.
  1519.      The expression involving howto->src_mask isolates the upper
  1520.      bit of src_mask.  If that bit is set in the value we are
  1521.      adding, it is negative, and we subtract out that number times
  1522.      two.  If src_mask includes the highest possible bit, then we
  1523.      can not get the upper bit, but that does not matter since
  1524.      signed_add needs no adjustment to become negative in that
  1525.      case.  */
  1526.       signed_add = add;
  1527.       if ((add & (((~howto->src_mask) >> 1) & howto->src_mask)) != 0)
  1528.     signed_add -= (((~howto->src_mask) >> 1) & howto->src_mask) << 1;
  1529.  
  1530.       /* Add the value from the object file, shifted so that it is a
  1531.      straight number.  */
  1532.       if (howto->bitpos == 0)
  1533.     {
  1534.       check += add;
  1535.       signed_check += signed_add;
  1536.     }
  1537.       else
  1538.     {
  1539.       check += add >> howto->bitpos;
  1540.  
  1541.       /* For the signed case we use ADD, rather than SIGNED_ADD,
  1542.          to avoid warnings from SVR4 cc.  This is OK since we
  1543.          explictly handle the sign bits.  */
  1544.       if (signed_add >= 0)
  1545.         signed_check += add >> howto->bitpos;
  1546.       else
  1547.         signed_check += ((add >> howto->bitpos)
  1548.                  | ((bfd_vma) - 1
  1549.                 & ~((bfd_vma) - 1 >> howto->bitpos)));
  1550.     }
  1551.  
  1552.       switch (howto->complain_on_overflow)
  1553.     {
  1554.     case complain_overflow_signed:
  1555.       {
  1556.         /* Assumes two's complement.  */
  1557.         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
  1558.         bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
  1559.  
  1560.         if (signed_check > reloc_signed_max
  1561.         || signed_check < reloc_signed_min)
  1562.           overflow = true;
  1563.       }
  1564.       break;
  1565.     case complain_overflow_unsigned:
  1566.       {
  1567.         /* Assumes two's complement.  This expression avoids
  1568.            overflow if howto->bitsize is the number of bits in
  1569.            bfd_vma.  */
  1570.         bfd_vma reloc_unsigned_max =
  1571.         (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
  1572.  
  1573.         if (check > reloc_unsigned_max)
  1574.           overflow = true;
  1575.       }
  1576.       break;
  1577.     case complain_overflow_bitfield:
  1578.       {
  1579.         /* Assumes two's complement.  This expression avoids
  1580.            overflow if howto->bitsize is the number of bits in
  1581.            bfd_vma.  */
  1582.         bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
  1583.  
  1584.         if ((check & ~reloc_bits) != 0
  1585.         && (((bfd_vma) signed_check & ~reloc_bits)
  1586.             != (-1 & ~reloc_bits)))
  1587.           overflow = true;
  1588.       }
  1589.       break;
  1590.     default:
  1591.       abort ();
  1592.     }
  1593.     }
  1594.  
  1595.   /* Put RELOCATION in the right bits.  */
  1596.   relocation >>= (bfd_vma) howto->rightshift;
  1597.   relocation <<= (bfd_vma) howto->bitpos;
  1598.  
  1599.   /* Add RELOCATION to the right bits of X.  */
  1600.   x = ((x & ~howto->dst_mask)
  1601.        | (((x & howto->src_mask) + relocation) & howto->dst_mask));
  1602.  
  1603.   /* Put the relocated value back in the object file.  */
  1604.   switch (size)
  1605.     {
  1606.     default:
  1607.     case 0:
  1608.       abort ();
  1609.     case 1:
  1610.       bfd_put_8 (input_bfd, x, location);
  1611.       break;
  1612.     case 2:
  1613.       bfd_put_16 (input_bfd, x, location);
  1614.       break;
  1615.     case 4:
  1616.       bfd_put_32 (input_bfd, x, location);
  1617.       break;
  1618.     case 8:
  1619. #ifdef BFD64
  1620.       bfd_put_64 (input_bfd, x, location);
  1621. #else
  1622.       abort ();
  1623. #endif
  1624.       break;
  1625.     }
  1626.  
  1627.   return overflow ? bfd_reloc_overflow : bfd_reloc_ok;
  1628. }
  1629.  
  1630. /*
  1631. DOCDD
  1632. INODE
  1633.     howto manager,  , typedef arelent, Relocations
  1634.  
  1635. SECTION
  1636.     The howto manager
  1637.  
  1638.     When an application wants to create a relocation, but doesn't
  1639.     know what the target machine might call it, it can find out by
  1640.     using this bit of code.
  1641.  
  1642. */
  1643.  
  1644. /*
  1645. TYPEDEF
  1646.     bfd_reloc_code_type
  1647.  
  1648. DESCRIPTION
  1649.     The insides of a reloc code.  The idea is that, eventually, there
  1650.     will be one enumerator for every type of relocation we ever do.
  1651.     Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
  1652.     return a howto pointer.
  1653.  
  1654.     This does mean that the application must determine the correct
  1655.     enumerator value; you can't get a howto pointer from a random set
  1656.     of attributes.
  1657.  
  1658. SENUM
  1659.    bfd_reloc_code_real
  1660.  
  1661. ENUM
  1662.   BFD_RELOC_64
  1663. ENUMX
  1664.   BFD_RELOC_32
  1665. ENUMX
  1666.   BFD_RELOC_26
  1667. ENUMX
  1668.   BFD_RELOC_16
  1669. ENUMX
  1670.   BFD_RELOC_14
  1671. ENUMX
  1672.   BFD_RELOC_8
  1673. ENUMDOC
  1674.   Basic absolute relocations of N bits.
  1675.  
  1676. ENUM
  1677.   BFD_RELOC_64_PCREL
  1678. ENUMX
  1679.   BFD_RELOC_32_PCREL
  1680. ENUMX
  1681.   BFD_RELOC_24_PCREL
  1682. ENUMX
  1683.   BFD_RELOC_16_PCREL
  1684. ENUMX
  1685.   BFD_RELOC_8_PCREL
  1686. ENUMDOC
  1687.   PC-relative relocations.  Sometimes these are relative to the address
  1688. of the relocation itself; sometimes they are relative to the start of
  1689. the section containing the relocation.  It depends on the specific target.
  1690.  
  1691. The 24-bit relocation is used in some Intel 960 configurations.
  1692.  
  1693. ENUM
  1694.   BFD_RELOC_32_BASEREL
  1695. ENUMX
  1696.   BFD_RELOC_16_BASEREL
  1697. ENUMX
  1698.   BFD_RELOC_8_BASEREL
  1699. ENUMDOC
  1700.   Linkage-table relative.
  1701.  
  1702. ENUM
  1703.   BFD_RELOC_8_FFnn
  1704. ENUMDOC
  1705.   Absolute 8-bit relocation, but used to form an address like 0xFFnn.
  1706.  
  1707. ENUM
  1708.   BFD_RELOC_32_PCREL_S2
  1709. ENUMX
  1710.   BFD_RELOC_16_PCREL_S2
  1711. ENUMX
  1712.   BFD_RELOC_23_PCREL_S2
  1713. ENUMDOC
  1714.   These PC-relative relocations are stored as word displacements --
  1715. i.e., byte displacements shifted right two bits.  The 30-bit word
  1716. displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
  1717. SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
  1718. signed 16-bit displacement is used on the MIPS, and the 23-bit
  1719. displacement is used on the Alpha.
  1720.  
  1721. ENUM
  1722.   BFD_RELOC_HI22
  1723. ENUMX
  1724.   BFD_RELOC_LO10
  1725. ENUMDOC
  1726.   High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
  1727. the target word.  These are used on the SPARC.
  1728.  
  1729. ENUM
  1730.   BFD_RELOC_GPREL16
  1731. ENUMX
  1732.   BFD_RELOC_GPREL32
  1733. ENUMDOC
  1734.   For systems that allocate a Global Pointer register, these are
  1735. displacements off that register.  These relocation types are
  1736. handled specially, because the value the register will have is
  1737. decided relatively late.
  1738.  
  1739.  
  1740. ENUM
  1741.   BFD_RELOC_I960_CALLJ
  1742. ENUMDOC
  1743.   Reloc types used for i960/b.out.
  1744.  
  1745. ENUM
  1746.   BFD_RELOC_NONE
  1747. ENUMX
  1748.   BFD_RELOC_SPARC_WDISP22
  1749. ENUMX
  1750.   BFD_RELOC_SPARC22
  1751. ENUMX
  1752.   BFD_RELOC_SPARC13
  1753. ENUMX
  1754.   BFD_RELOC_SPARC_GOT10
  1755. ENUMX
  1756.   BFD_RELOC_SPARC_GOT13
  1757. ENUMX
  1758.   BFD_RELOC_SPARC_GOT22
  1759. ENUMX
  1760.   BFD_RELOC_SPARC_PC10
  1761. ENUMX
  1762.   BFD_RELOC_SPARC_PC22
  1763. ENUMX
  1764.   BFD_RELOC_SPARC_WPLT30
  1765. ENUMX
  1766.   BFD_RELOC_SPARC_COPY
  1767. ENUMX
  1768.   BFD_RELOC_SPARC_GLOB_DAT
  1769. ENUMX
  1770.   BFD_RELOC_SPARC_JMP_SLOT
  1771. ENUMX
  1772.   BFD_RELOC_SPARC_RELATIVE
  1773. ENUMX
  1774.   BFD_RELOC_SPARC_UA32
  1775. ENUMDOC
  1776.   SPARC ELF relocations.  There is probably some overlap with other
  1777.   relocation types already defined.
  1778.  
  1779. ENUM
  1780.   BFD_RELOC_SPARC_BASE13
  1781. ENUMX
  1782.   BFD_RELOC_SPARC_BASE22
  1783. ENUMDOC
  1784.   I think these are specific to SPARC a.out (e.g., Sun 4).
  1785.  
  1786. ENUMEQ
  1787.   BFD_RELOC_SPARC_64
  1788.   BFD_RELOC_64
  1789. ENUMX
  1790.   BFD_RELOC_SPARC_10
  1791. ENUMX
  1792.   BFD_RELOC_SPARC_11
  1793. ENUMX
  1794.   BFD_RELOC_SPARC_OLO10
  1795. ENUMX
  1796.   BFD_RELOC_SPARC_HH22
  1797. ENUMX
  1798.   BFD_RELOC_SPARC_HM10
  1799. ENUMX
  1800.   BFD_RELOC_SPARC_LM22
  1801. ENUMX
  1802.   BFD_RELOC_SPARC_PC_HH22
  1803. ENUMX
  1804.   BFD_RELOC_SPARC_PC_HM10
  1805. ENUMX
  1806.   BFD_RELOC_SPARC_PC_LM22
  1807. ENUMX
  1808.   BFD_RELOC_SPARC_WDISP16
  1809. ENUMX
  1810.   BFD_RELOC_SPARC_WDISP19
  1811. ENUMX
  1812.   BFD_RELOC_SPARC_GLOB_JMP
  1813. ENUMX
  1814.   BFD_RELOC_SPARC_LO7
  1815. ENUMDOC
  1816.   Some relocations we're using for SPARC V9 -- subject to change.
  1817.  
  1818. ENUM
  1819.   BFD_RELOC_ALPHA_GPDISP_HI16
  1820. ENUMDOC
  1821.   Alpha ECOFF relocations.  Some of these treat the symbol or "addend"
  1822.      in some special way.
  1823.   For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
  1824.      writing; when reading, it will be the absolute section symbol.  The
  1825.      addend is the displacement in bytes of the "lda" instruction from
  1826.      the "ldah" instruction (which is at the address of this reloc).
  1827. ENUM
  1828.   BFD_RELOC_ALPHA_GPDISP_LO16
  1829. ENUMDOC
  1830.   For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
  1831.      with GPDISP_HI16 relocs.  The addend is ignored when writing the
  1832.      relocations out, and is filled in with the file's GP value on
  1833.      reading, for convenience.
  1834.  
  1835. ENUM
  1836.   BFD_RELOC_ALPHA_LITERAL
  1837. ENUMX
  1838.   BFD_RELOC_ALPHA_LITUSE
  1839. ENUMDOC
  1840.   The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
  1841.      the assembler turns it into a LDQ instruction to load the address of
  1842.      the symbol, and then fills in a register in the real instruction.
  1843.  
  1844.      The LITERAL reloc, at the LDQ instruction, refers to the .lita
  1845.      section symbol.  The addend is ignored when writing, but is filled
  1846.      in with the file's GP value on reading, for convenience, as with the
  1847.      GPDISP_LO16 reloc.
  1848.  
  1849.      The LITUSE reloc, on the instruction using the loaded address, gives
  1850.      information to the linker that it might be able to use to optimize
  1851.      away some literal section references.  The symbol is ignored (read
  1852.      as the absolute section symbol), and the "addend" indicates the type
  1853.      of instruction using the register:
  1854.               1 - "memory" fmt insn
  1855.               2 - byte-manipulation (byte offset reg)
  1856.               3 - jsr (target of branch)
  1857.  
  1858.      The GNU linker currently doesn't do any of this optimizing.
  1859.  
  1860. ENUM
  1861.   BFD_RELOC_ALPHA_HINT
  1862. ENUMDOC
  1863.   The HINT relocation indicates a value that should be filled into the
  1864.      "hint" field of a jmp/jsr/ret instruction, for possible branch-
  1865.      prediction logic which may be provided on some processors.
  1866.  
  1867. ENUM
  1868.   BFD_RELOC_MIPS_JMP
  1869. ENUMDOC
  1870.   Bits 27..2 of the relocation address shifted right 2 bits;
  1871.      simple reloc otherwise.
  1872.  
  1873. ENUM
  1874.   BFD_RELOC_HI16
  1875. ENUMDOC
  1876.   High 16 bits of 32-bit value; simple reloc.
  1877. ENUM
  1878.   BFD_RELOC_HI16_S
  1879. ENUMDOC
  1880.   High 16 bits of 32-bit value but the low 16 bits will be sign
  1881.      extended and added to form the final result.  If the low 16
  1882.      bits form a negative number, we need to add one to the high value
  1883.      to compensate for the borrow when the low bits are added.
  1884. ENUM
  1885.   BFD_RELOC_LO16
  1886. ENUMDOC
  1887.   Low 16 bits.
  1888. ENUM
  1889.   BFD_RELOC_PCREL_HI16_S
  1890. ENUMDOC
  1891.   Like BFD_RELOC_HI16_S, but PC relative.
  1892. ENUM
  1893.   BFD_RELOC_PCREL_LO16
  1894. ENUMDOC
  1895.   Like BFD_RELOC_LO16, but PC relative.
  1896.  
  1897. ENUMEQ
  1898.   BFD_RELOC_MIPS_GPREL
  1899.   BFD_RELOC_GPREL16
  1900. ENUMDOC
  1901.   Relocation relative to the global pointer.
  1902.  
  1903. ENUM
  1904.   BFD_RELOC_MIPS_LITERAL
  1905. ENUMDOC
  1906.   Relocation against a MIPS literal section.
  1907.  
  1908. ENUM
  1909.   BFD_RELOC_MIPS_GOT16
  1910. ENUMX
  1911.   BFD_RELOC_MIPS_CALL16
  1912. ENUMEQX
  1913.   BFD_RELOC_MIPS_GPREL32
  1914.   BFD_RELOC_GPREL32
  1915. ENUMDOC
  1916.   MIPS ELF relocations.
  1917.  
  1918. ENUM
  1919.   BFD_RELOC_386_GOT32
  1920. ENUMX
  1921.   BFD_RELOC_386_PLT32
  1922. ENUMX
  1923.   BFD_RELOC_386_COPY
  1924. ENUMX
  1925.   BFD_RELOC_386_GLOB_DAT
  1926. ENUMX
  1927.   BFD_RELOC_386_JUMP_SLOT
  1928. ENUMX
  1929.   BFD_RELOC_386_RELATIVE
  1930. ENUMX
  1931.   BFD_RELOC_386_GOTOFF
  1932. ENUMX
  1933.   BFD_RELOC_386_GOTPC
  1934. ENUMDOC
  1935.   i386/elf relocations
  1936.  
  1937. ENUM
  1938.   BFD_RELOC_NS32K_IMM_8
  1939. ENUMX
  1940.   BFD_RELOC_NS32K_IMM_16
  1941. ENUMX
  1942.   BFD_RELOC_NS32K_IMM_32
  1943. ENUMX
  1944.   BFD_RELOC_NS32K_IMM_8_PCREL
  1945. ENUMX
  1946.   BFD_RELOC_NS32K_IMM_16_PCREL
  1947. ENUMX
  1948.   BFD_RELOC_NS32K_IMM_32_PCREL
  1949. ENUMX
  1950.   BFD_RELOC_NS32K_DISP_8
  1951. ENUMX
  1952.   BFD_RELOC_NS32K_DISP_16
  1953. ENUMX
  1954.   BFD_RELOC_NS32K_DISP_32
  1955. ENUMX
  1956.   BFD_RELOC_NS32K_DISP_8_PCREL
  1957. ENUMX
  1958.   BFD_RELOC_NS32K_DISP_16_PCREL
  1959. ENUMX
  1960.   BFD_RELOC_NS32K_DISP_32_PCREL
  1961. ENUMDOC
  1962.   ns32k relocations
  1963.  
  1964. ENUM
  1965.   BFD_RELOC_PPC_B26
  1966. ENUMDOC
  1967.   PowerPC/POWER (RS/6000) relocs.
  1968.   26 bit relative branch.  Low two bits must be zero.  High 24
  1969.      bits installed in bits 6 through 29 of instruction.
  1970. ENUM
  1971.   BFD_RELOC_PPC_BA26
  1972. ENUMDOC
  1973.   26 bit absolute branch, like BFD_RELOC_PPC_B26 but absolute.
  1974. ENUM
  1975.   BFD_RELOC_PPC_TOC16
  1976. ENUMDOC
  1977.   16 bit TOC relative reference.
  1978.  
  1979. ENUM
  1980.   BFD_RELOC_CTOR
  1981. ENUMDOC
  1982.   The type of reloc used to build a contructor table - at the moment
  1983.   probably a 32 bit wide absolute relocation, but the target can choose.
  1984.   It generally does map to one of the other relocation types.
  1985.  
  1986. ENUM
  1987.   BFD_RELOC_ARM_PCREL_BRANCH
  1988. ENUMDOC
  1989.   ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
  1990.   not stored in the instruction.
  1991. ENUM
  1992.   BFD_RELOC_ARM_IMMEDIATE
  1993. ENUMX
  1994.   BFD_RELOC_ARM_OFFSET_IMM
  1995. ENUMX
  1996.   BFD_RELOC_ARM_SHIFT_IMM
  1997. ENUMX
  1998.   BFD_RELOC_ARM_SWI
  1999. ENUMX
  2000.   BFD_RELOC_ARM_MULTI
  2001. ENUMX
  2002.   BFD_RELOC_ARM_CP_OFF_IMM
  2003. ENUMDOC
  2004.   These relocs are only used within the ARM assembler.  They are not
  2005.   (at present) written to any object files.
  2006.  
  2007. ENDSENUM
  2008.   BFD_RELOC_UNUSED
  2009.  
  2010. CODE_FRAGMENT
  2011. .
  2012. .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
  2013. */
  2014.  
  2015.  
  2016. /*
  2017. FUNCTION
  2018.     bfd_reloc_type_lookup
  2019.  
  2020. SYNOPSIS
  2021.     const struct reloc_howto_struct *
  2022.     bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
  2023.  
  2024. DESCRIPTION
  2025.     Return a pointer to a howto structure which, when
  2026.     invoked, will perform the relocation @var{code} on data from the
  2027.     architecture noted.
  2028.  
  2029. */
  2030.  
  2031.  
  2032. const struct reloc_howto_struct *
  2033. bfd_reloc_type_lookup (abfd, code)
  2034.      bfd *abfd;
  2035.      bfd_reloc_code_real_type code;
  2036. {
  2037.   return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
  2038. }
  2039.  
  2040. static reloc_howto_type bfd_howto_32 =
  2041. HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
  2042.  
  2043.  
  2044. /*
  2045. INTERNAL_FUNCTION
  2046.     bfd_default_reloc_type_lookup
  2047.  
  2048. SYNOPSIS
  2049.     const struct reloc_howto_struct *bfd_default_reloc_type_lookup
  2050.     (bfd *abfd, bfd_reloc_code_real_type  code);
  2051.  
  2052. DESCRIPTION
  2053.     Provides a default relocation lookup routine for any architecture.
  2054.  
  2055.  
  2056. */
  2057.  
  2058. const struct reloc_howto_struct *
  2059. bfd_default_reloc_type_lookup (abfd, code)
  2060.      bfd *abfd;
  2061.      bfd_reloc_code_real_type code;
  2062. {
  2063.   switch (code)
  2064.     {
  2065.     case BFD_RELOC_CTOR:
  2066.       /* The type of reloc used in a ctor, which will be as wide as the
  2067.      address - so either a 64, 32, or 16 bitter.  */
  2068.       switch (bfd_get_arch_info (abfd)->bits_per_address)
  2069.     {
  2070.     case 64:
  2071.       BFD_FAIL ();
  2072.     case 32:
  2073.       return &bfd_howto_32;
  2074.     case 16:
  2075.       BFD_FAIL ();
  2076.     default:
  2077.       BFD_FAIL ();
  2078.     }
  2079.     default:
  2080.       BFD_FAIL ();
  2081.     }
  2082.   return (const struct reloc_howto_struct *) NULL;
  2083. }
  2084.  
  2085. /*
  2086. FUNCTION
  2087.     bfd_get_reloc_code_name
  2088.  
  2089. SYNOPSIS
  2090.     const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
  2091.  
  2092. DESCRIPTION
  2093.     Provides a printable name for the supplied relocation code.
  2094.     Useful mainly for printing error messages.
  2095. */
  2096.  
  2097. const char *
  2098. bfd_get_reloc_code_name (code)
  2099.      bfd_reloc_code_real_type code;
  2100. {
  2101.   if (code > BFD_RELOC_UNUSED)
  2102.     return 0;
  2103.   return bfd_reloc_code_real_names[(int)code];
  2104. }
  2105.  
  2106. /*
  2107. INTERNAL_FUNCTION
  2108.     bfd_generic_relax_section
  2109.  
  2110. SYNOPSIS
  2111.     boolean bfd_generic_relax_section
  2112.      (bfd *abfd,
  2113.       asection *section,
  2114.       struct bfd_link_info *,
  2115.       boolean *);
  2116.  
  2117. DESCRIPTION
  2118.     Provides default handling for relaxing for back ends which
  2119.     don't do relaxing -- i.e., does nothing.
  2120. */
  2121.  
  2122. /*ARGSUSED*/
  2123. boolean
  2124. bfd_generic_relax_section (abfd, section, link_info, again)
  2125.      bfd *abfd;
  2126.      asection *section;
  2127.      struct bfd_link_info *link_info;
  2128.      boolean *again;
  2129. {
  2130.   *again = false;
  2131.   return true;
  2132. }
  2133.  
  2134. /*
  2135. INTERNAL_FUNCTION
  2136.     bfd_generic_get_relocated_section_contents
  2137.  
  2138. SYNOPSIS
  2139.     bfd_byte *
  2140.        bfd_generic_get_relocated_section_contents (bfd *abfd,
  2141.          struct bfd_link_info *link_info,
  2142.          struct bfd_link_order *link_order,
  2143.          bfd_byte *data,
  2144.          boolean relocateable,
  2145.          asymbol **symbols);
  2146.  
  2147. DESCRIPTION
  2148.     Provides default handling of relocation effort for back ends
  2149.     which can't be bothered to do it efficiently.
  2150.  
  2151. */
  2152.  
  2153. bfd_byte *
  2154. bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
  2155.                         relocateable, symbols)
  2156.      bfd *abfd;
  2157.      struct bfd_link_info *link_info;
  2158.      struct bfd_link_order *link_order;
  2159.      bfd_byte *data;
  2160.      boolean relocateable;
  2161.      asymbol **symbols;
  2162. {
  2163.   /* Get enough memory to hold the stuff */
  2164.   bfd *input_bfd = link_order->u.indirect.section->owner;
  2165.   asection *input_section = link_order->u.indirect.section;
  2166.  
  2167.   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
  2168.   arelent **reloc_vector = NULL;
  2169.   long reloc_count;
  2170.  
  2171.   if (reloc_size < 0)
  2172.     goto error_return;
  2173.  
  2174.   reloc_vector = (arelent **) malloc (reloc_size);
  2175.   if (reloc_vector == NULL && reloc_size != 0)
  2176.     {
  2177.       bfd_set_error (bfd_error_no_memory);
  2178.       goto error_return;
  2179.     }
  2180.  
  2181.   /* read in the section */
  2182.   if (!bfd_get_section_contents (input_bfd,
  2183.                  input_section,
  2184.                  (PTR) data,
  2185.                  0,
  2186.                  input_section->_raw_size))
  2187.     goto error_return;
  2188.  
  2189.   /* We're not relaxing the section, so just copy the size info */
  2190.   input_section->_cooked_size = input_section->_raw_size;
  2191.   input_section->reloc_done = true;
  2192.  
  2193.   reloc_count = bfd_canonicalize_reloc (input_bfd,
  2194.                     input_section,
  2195.                     reloc_vector,
  2196.                     symbols);
  2197.   if (reloc_count < 0)
  2198.     goto error_return;
  2199.  
  2200.   if (reloc_count > 0)
  2201.     {
  2202.       arelent **parent;
  2203.       for (parent = reloc_vector; *parent != (arelent *) NULL;
  2204.        parent++)
  2205.     {
  2206.       char *error_message = (char *) NULL;
  2207.       bfd_reloc_status_type r =
  2208.         bfd_perform_relocation (input_bfd,
  2209.                     *parent,
  2210.                     (PTR) data,
  2211.                     input_section,
  2212.                     relocateable ? abfd : (bfd *) NULL,
  2213.                     &error_message);
  2214.  
  2215.       if (relocateable)
  2216.         {
  2217.           asection *os = input_section->output_section;
  2218.  
  2219.           /* A partial link, so keep the relocs */
  2220.           os->orelocation[os->reloc_count] = *parent;
  2221.           os->reloc_count++;
  2222.         }
  2223.  
  2224.       if (r != bfd_reloc_ok)
  2225.         {
  2226.           switch (r)
  2227.         {
  2228.         case bfd_reloc_undefined:
  2229.           if (!((*link_info->callbacks->undefined_symbol)
  2230.             (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
  2231.              input_bfd, input_section, (*parent)->address)))
  2232.             goto error_return;
  2233.           break;
  2234.         case bfd_reloc_dangerous:
  2235.           BFD_ASSERT (error_message != (char *) NULL);
  2236.           if (!((*link_info->callbacks->reloc_dangerous)
  2237.             (link_info, error_message, input_bfd, input_section,
  2238.              (*parent)->address)))
  2239.             goto error_return;
  2240.           break;
  2241.         case bfd_reloc_overflow:
  2242.           if (!((*link_info->callbacks->reloc_overflow)
  2243.             (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
  2244.              (*parent)->howto->name, (*parent)->addend,
  2245.              input_bfd, input_section, (*parent)->address)))
  2246.             goto error_return;
  2247.           break;
  2248.         case bfd_reloc_outofrange:
  2249.         default:
  2250.           abort ();
  2251.           break;
  2252.         }
  2253.  
  2254.         }
  2255.     }
  2256.     }
  2257.   if (reloc_vector != NULL)
  2258.     free (reloc_vector);
  2259.   return data;
  2260.  
  2261. error_return:
  2262.   if (reloc_vector != NULL)
  2263.     free (reloc_vector);
  2264.   return NULL;
  2265. }
  2266.